package chemins.pack;

import java.text.DecimalFormat;
import java.util.ArrayList;
import java.util.List;

import chemin.pack.R;

import android.content.Context;
import android.content.SharedPreferences;
import android.graphics.*;
import android.os.Message;
import android.util.AttributeSet;
import android.util.FloatMath;
import android.util.Log;
import android.view.MotionEvent;
import android.view.View;
import android.view.View.OnTouchListener;
import android.widget.ImageView;
import communication.IncomingHandler;
import java.util.Random;

public class DrawViewChemin extends View  implements OnTouchListener {
		    
                    IncomingHandler handler;
                    SharedPreferences preferences;
                    EasterEgg easterEgg;
                    
                    Boolean touchable = true;
                    
                    Boolean cheminModulable = false;
                    String typeChemin= null;
			
                    Boolean monChemin = false;
                    Boolean cheminTDF = false;
			
                    double ponderationPente = 0.2;
	
                    private static final String TAG = "DrawView";
		    Paint cheminPaint = new Paint();
		    Paint pointPaint = new Paint();
		    Paint distancesPaint = new Paint();
		    Paint flechePaint = new Paint();
		    Paint hauteurPaint = new Paint();
		    Paint portionPaint = new Paint();
		    Paint veloPaint = new Paint();
		    Paint whitePaint = new Paint();

                    Parcours parcours= new Parcours();
                    
		    Point pointBis = new Point();
		    float oldDistanceOnTouchPoints;
		    float newDistanceOnTouchPoints;
		    
		    int distanceTotale = 1000;
                    int distanceFinale = 0;
                    int hauteurFinale = 0;
                    int hauteurInitiale = 0;
                    int pointLePlusBas =0;
                    
                    
		    float y_min= 340;
		    float y_max = 570;
		    float x_depart_init= 185;
		    float x_arrivee_init = 1100;
                    

		    
		    float ecartPointsMin = 150;
		    int touchZone = 40;
		    int penteMax = 20;
		    int penteMin = -20;
		    int unKm;
		    Echelle echelle = new Echelle();

		    int hauteurFleche = 650;    
		   
		    Velo velo = new Velo();
                    
                    
                    public int getSlope(){
                        return velo.pente;
                    }
                    
		    
                    public int getDistance(){
                        return (int)velo.distanceParcourue;
                    }
                    
		    DecimalFormat df = new DecimalFormat ( ) ; 

		    PortionDeChemin maPortion =new PortionDeChemin();
		    
                    
		    
		    
		
		    public DrawViewChemin(Context context, AttributeSet attrs,IncomingHandler handler,Boolean cheminModulable,String typeChemin) {
		        super(context);
		        
                        preferences = context.getSharedPreferences("myPreferences",Context.MODE_MULTI_PROCESS);
                        penteMin = preferences.getInt("penteMin", -20);
                        this.penteMin = penteMin;
                        penteMax = preferences.getInt("penteMax", 20);
                        this.penteMax = penteMax;
                        
                        
                        
                        this.handler = handler;
		        this.typeChemin=typeChemin;
		        this.cheminModulable=cheminModulable;
		        
		        
		        cheminPaint.setColor(Color.parseColor("#FFFF00"));
		        cheminPaint.setAntiAlias(true);
		        cheminPaint.setStrokeWidth(3);
		        pointPaint.setColor(Color.parseColor("#111011"));
		        pointPaint.setAntiAlias(true);
		        distancesPaint.setColor(Color.parseColor("#111011"));
		        distancesPaint.setAntiAlias(true);
		        distancesPaint.setTypeface(Typeface.DEFAULT_BOLD);
		        hauteurPaint.setColor(Color.parseColor("#111011"));
		        hauteurPaint.setStrokeWidth(1);
		        hauteurPaint. setAntiAlias(true);
		        flechePaint.setColor(Color.parseColor("#111011"));
		        flechePaint.setAntiAlias(true);
		        flechePaint.setStrokeWidth(3);
		        //portionPaint.setColor(Color.parseColor("#20111011"));
		        portionPaint.setColor(Color.parseColor("#805dc5c3"));
                        //portionPaint.setAntiAlias(true);
		        veloPaint.setColor(Color.parseColor("#F29022"));
		        veloPaint.setAntiAlias(true);
                        veloPaint.setStrokeWidth(3);
		        veloPaint.setShader(null);
                        
                        whitePaint.setColor(Color.parseColor("#FFFFFF"));
		        whitePaint.setAntiAlias(true);
		        
		        
		        df.setMinimumFractionDigits( 0 ) ;
                        df.setMaximumFractionDigits( 1 );
		        df.setDecimalSeparatorAlwaysShown( false ) ; 
		        
		        Canvas canvas;
                        
                        parcours.setSize(0);
                        
		        
		        initialiserChemin();
		        
		        
		        setFocusable(true);
		        setFocusableInTouchMode(true);
		
		        this.setOnTouchListener(this);
		
                        easterEgg = new EasterEgg(getResources());
		    }
                    
                    
                    public void miseEnFormeCheminTDF(){
                            
                            int i;
                            
                            echelle.value= (float) 1+ 1/10000000;
                            echelle.ponderation = (float) 1.2;
                            echelle.ponderation1 = (float) 1.03;
                            distanceTotale = (int) parcours.tab[parcours.getSize()-1].getDistance();
                            
                            for (i=0;i<parcours.getSize();i++)
                            {
                                if(parcours.tab[i].getHauteur() > hauteurFinale)
                                {
                                    hauteurFinale = (int)(parcours.tab[i].getHauteur());
                                }
                                 
                            }
                           
                            maPortion.xMax = (int) (x_arrivee_init + 10);
                            maPortion.xMin = (int) (x_depart_init - 10);
                            maPortion.depart = (int) (x_depart_init+ (x_arrivee_init-x_depart_init)/4);
                            maPortion.arrivee = (int) (x_depart_init+ 3*(x_arrivee_init-x_depart_init)/4);

                            velo.x = maPortion.depart;



                            hauteurInitiale = (int) parcours.tab[0].getHauteur();
                            for(i=0;i<parcours.getSize();i++)
                            {
                                    parcours.tab[i].x = (float) (x_depart_init+(x_arrivee_init-x_depart_init)/(distanceTotale)*parcours.tab[i].distance);
                                    parcours.tab[i].y= y_max -((float)(((parcours.tab[i].getHauteur()*(y_max-y_min))/(hauteurFinale)*echelle.value)));

                            }
                    }
                    
                    
		    public void initialiserChemin() {
				// TODO Auto-generated method stub
		    	
		        echelle.value= (float) 1+ 1/10000000;
		        echelle.ponderation = (float) 1.2;
		        echelle.ponderation1 = (float) 1.03;
		    	
                        parcours.tab=  new Point[100];
			    	
                        parcours.tab[0]= new Point();
                        parcours.tab[0].x = x_depart_init;
                        parcours.tab[0].y= y_max;
                        parcours.tab[0].setDistance(0);
                        parcours.tab[0].setHauteur(0);
                        parcours.tab[0].pente = 0;

                        parcours.tab[1]= new Point();
                        parcours.tab[1].x= x_arrivee_init;
                        parcours.tab[1].y= y_max;
                        parcours.tab[1].setDistance(distanceTotale);
                        parcours.tab[1].setHauteur(0);

                        parcours.setSize(2);
				    	
                                        
                        
		    	if(typeChemin.equals("monChemin"))
		        {

			        velo.x = (int)x_depart_init;
			        velo.distanceParcourue = 0;
		        }
		        
		        

		        
		        velo.image = BitmapFactory.decodeResource(getResources(), R.drawable.velo);

		        velo.y = (int) hauteurFleche - velo.image.getHeight();
		        velo.pente = 0;
		        
                        
			}

//__________________________________________________________________________________________________________________________________________________________			    
		    
			@Override
		    public void onDraw(Canvas canvas) {

		        	int i=0,j=0;
		        	
                                
				    
        			while(i<=parcours.getSize()-1)
		        	{
        				
	        			if(parcours.tab[i].y>y_max)
	        			{
	        				parcours.tab[i].y = y_max;
	        			}
			        	
		        		
		        		parcours.tab[i].setHauteur(  y_max -parcours.tab[i].y );
		        		
                                        if(typeChemin.equals("monChemin"))
                                        {
                                            parcours.tab[i].setHauteur((float)((parcours.tab[i].getHauteur())/(y_max-y_min)*((float)penteMax/100)*distanceTotale*echelle.value));
                                        }
                                        
                                        if((typeChemin.equals("cheminTDF"))||(typeChemin.equals("monCheminTDF")))
                                        {
                                            parcours.tab[i].setHauteur((float)((parcours.tab[i].getHauteur())/(y_max-y_min)*(hauteurFinale)*echelle.value));
                                           
                                        } 
                                        
		        		
		        		if(i!=0)
		        		{
		        			
		        			
		        			parcours.tab[i].setDistance(( Math.sqrt(Math.pow((parcours.tab[i].x-parcours.tab[i-1].x)/(x_arrivee_init-x_depart_init)*distanceTotale,2) +Math.pow(parcours.tab[i].getHauteur()-parcours.tab[i-1].getHauteur(), 2))));
		        			parcours.tab[i].setDistance( (parcours.tab[i].getDistance()) + parcours.tab[i-1].getDistance());
		        			
		        			parcours.tab[i].pente = (int)((parcours.tab[i-1].hauteur-parcours.tab[i].hauteur)/(parcours.tab[i-1].distance-parcours.tab[i].distance)*100);
		        			
		        			
		        			while (((parcours.tab[i].pente>penteMax)||(parcours.tab[i].pente<penteMin)))
		        			{
		        				if(parcours.tab[i].pente>penteMax)
		        				{
		        					
		        					parcours.tab[i].y++;
		        				}
		        				else
		        				{
		        					parcours.tab[i].y--;
		        				}
		        				parcours.tab[i].setHauteur(  y_max -parcours.tab[i].y);
				        		parcours.tab[i].setHauteur((float)((parcours.tab[i].getHauteur())/(y_max-y_min)*ponderationPente*distanceTotale*echelle.value));
		        				
		        				parcours.tab[i].setDistance(( Math.sqrt(Math.pow((parcours.tab[i].x-parcours.tab[i-1].x)/(x_arrivee_init-x_depart_init)*distanceTotale,2) +Math.pow(parcours.tab[i].getHauteur()-parcours.tab[i-1].getHauteur(), 2))));
			        			parcours.tab[i].setDistance( (parcours.tab[i].getDistance()) + parcours.tab[i-1].getDistance());
			        				        				
		        				parcours.tab[i].pente = (int)((parcours.tab[i-1].hauteur-parcours.tab[i].hauteur)/(parcours.tab[i-1].distance-parcours.tab[i].distance)*100);
			        			
		        			}
		        			
		        			if((parcours.tab[i].pente)>=0 && (parcours.tab[i].pente)<=penteMax)
		        			{
		        				cheminPaint.setColor(Color.parseColor("#FF" +Integer.toHexString(255-(parcours.tab[i].pente*10)) +   "43"));
		        			}
		        			
		        			
		        			if((parcours.tab[i].pente)<0 && (parcours.tab[i].pente)>=penteMin)
		        			{		        				
		        				cheminPaint.setColor(Color.parseColor("#"+Integer.toHexString( 255+(parcours.tab[i].pente*(-penteMin/2))) +   "ff00"));
		        			}
		        			
		        			

		        			if(typeChemin.equals("cheminTDF"))
		        			{
		        				canvas.drawLine(parcours.tab[i].x, parcours.tab[i].y, parcours.tab[i].x, y_max, hauteurPaint);
		        				
		        				if(i<parcours.getSize()-1)
				        		{

				        			canvas.drawText("" +df.format(parcours.tab[i].getDistance()/1000) , parcours.tab[i].x-4, y_max+20, distancesPaint);
				        		}
				        		else
				        		{
				        			canvas.drawText(df.format(parcours.tab[i].getDistance()/1000) +" km" , parcours.tab[i].x-4, y_max+20, distancesPaint);
				        		}
		        				
		        			}
		        			
		        			
		        			
		        			canvas.drawLine(parcours.tab[i-1].x, parcours.tab[i-1].y, parcours.tab[i].x, parcours.tab[i].y, cheminPaint);
		        			
		        			
		        			
		        			if((typeChemin.equals("monChemin"))||(typeChemin.equals("monCheminTDF")))
		        			{
		        				canvas.drawCircle(parcours.tab[i-1].x, parcours.tab[i-1].y, 5, pointPaint);
		        			}
		        			
		        			
		        			
		        			
		        			canvas.drawText(parcours.tab[i].pente +"%" , (parcours.tab[i].x + parcours.tab[i-1].x)/2, (parcours.tab[i].y + parcours.tab[i-1].y)/2, distancesPaint);
		        		}
		        		
		        		
		        		if((typeChemin.equals("monChemin"))||(typeChemin.equals("monCheminTDF")))
	        			{
				        	canvas.drawText("h: "+ (int)parcours.tab[i].getHauteur() +"m" , parcours.tab[i].x-20, parcours.tab[i].y - 30, distancesPaint);
					        canvas.drawText("d: "+(int)parcours.tab[i].getDistance() +"m" , parcours.tab[i].x-20, parcours.tab[i].y - 15, distancesPaint);
	        			}
		        		
		        		
		        		
		        		
		        		if((typeChemin.equals("cheminTDF"))&&(i<parcours.getSize() -1))
		        		{
		        			if(i==0)
				        	{
				        		canvas.drawText("0m" , x_arrivee_init + 12, y_max , distancesPaint);
			        			canvas.drawLine(x_depart_init,y_max,x_arrivee_init + 8,y_max, hauteurPaint);
			        			canvas.drawText("" +(int) parcours.tab[i].getDistance()/1000 , parcours.tab[i].x-4, y_max+20, distancesPaint);
			        			canvas.drawLine(parcours.tab[i].x, parcours.tab[i].y, parcours.tab[i].x, y_max, hauteurPaint);
				        	}
				        	
	        				if((maPortion.depart>=parcours.tab[i].x)&&(maPortion.depart<=parcours.tab[i+1].x))
			        		{
			        			
	        					
	        					maPortion.hauteur=(int) (parcours.tab[i].hauteur + ((maPortion.depart -parcours.tab[i].x)/(parcours.tab[i+1].x-parcours.tab[i].x))*(parcours.tab[i+1].hauteur-parcours.tab[i].hauteur));
	        					maPortion.yDepart=(int) (parcours.tab[i].y + ((maPortion.depart -parcours.tab[i].x)/(parcours.tab[i+1].x-parcours.tab[i].x))*(parcours.tab[i+1].y-parcours.tab[i].y));
	        					
	        					
			        			canvas.drawText(""+ maPortion.hauteur +"m" , x_arrivee_init + 12,maPortion.yDepart, distancesPaint);
			        			
			        			canvas.drawLine(maPortion.depart,maPortion.yDepart,x_arrivee_init + 8,maPortion.yDepart, hauteurPaint);
			        			
			        		}
	        				
	        				if((maPortion.arrivee >= parcours.tab[i].x)&&(maPortion.arrivee <= parcours.tab[i+1].x))
			        		{
			        			
	        					
	        					
	        					maPortion.hauteur=(int) (parcours.tab[i].hauteur + ((maPortion.arrivee -parcours.tab[i].x)/(parcours.tab[i+1].x-parcours.tab[i].x))*(parcours.tab[i+1].hauteur-parcours.tab[i].hauteur));
	        					maPortion.yArrivee=(int) (parcours.tab[i].y + ((maPortion.arrivee -parcours.tab[i].x)/(parcours.tab[i+1].x-parcours.tab[i].x))*(parcours.tab[i+1].y-parcours.tab[i].y));
	        					

	        					
			        			canvas.drawText(""+ maPortion.hauteur +"m" , x_arrivee_init + 12,maPortion.yArrivee, distancesPaint);
			        					        			
			        			canvas.drawLine(maPortion.arrivee,maPortion.yArrivee,x_arrivee_init + 8,maPortion.yArrivee, hauteurPaint);

			        		}
	        				
	        			
        				
		        			
		        		}
		        		
		        		
		        		

					    i++;


		        	}
        			
        			
        			
        			distanceFinale = (int) parcours.tab[i-1].distance;
		        	parcours.tab[0].setHauteur(  y_max -parcours.tab[0].y);
		            
		        	
		        	
		        	
//_________________________		
		        	
		        	// Portion
		        	
		        	if(typeChemin.equals("cheminTDF"))
		        	{
                                        unKm = (int) (parcours.tab[1].x - parcours.tab[0].x);
		        		canvas.drawRect(maPortion.xMin , y_min, maPortion.depart, y_max, portionPaint);
			        	canvas.drawLine(maPortion.depart, y_min, maPortion.depart, y_max, flechePaint);
			        	canvas.drawRect(maPortion.arrivee, y_min,maPortion.xMax  , y_max, portionPaint);
			        	canvas.drawLine(maPortion.arrivee, y_min, maPortion.arrivee, y_max, flechePaint);
		        	}
		        	
                                
                                
                                if((typeChemin.equals("monChemin"))||(typeChemin.equals("monCheminTDF")))
        			{
		        		canvas.drawCircle(parcours.tab[0].x, parcours.tab[0].y, 10, pointPaint);
		        		canvas.drawCircle(parcours.tab[i-1].x, parcours.tab[i-1].y, 10, pointPaint);		
        			
		        	

                                        
                                        // Fl�che

                                        canvas.drawLine(x_depart_init - velo.image.getWidth()/2, hauteurFleche, x_arrivee_init+velo.image.getWidth()/2, hauteurFleche, flechePaint);
                                        canvas.drawLine(x_depart_init - velo.image.getWidth()/2, hauteurFleche - 10, x_depart_init - velo.image.getWidth()/2, hauteurFleche + 10, flechePaint);
                                        canvas.drawLine(x_arrivee_init + velo.image.getWidth()/2 - 10, hauteurFleche - 10, x_arrivee_init+velo.image.getWidth()/2, hauteurFleche, flechePaint);
                                        canvas.drawLine(x_arrivee_init + velo.image.getWidth()/2 - 10, hauteurFleche + 10, x_arrivee_init+velo.image.getWidth()/2, hauteurFleche, flechePaint);

                                        // V�lo
                                        j=0;
                                        while(j < parcours.getSize()-1)
                                        {
                                                if((parcours.tab[j].distance <= velo.distanceParcourue)&&(parcours.tab[j+1].distance >= velo.distanceParcourue))
                                                {
                                                        velo.x = (int) (((velo.distanceParcourue-parcours.tab[j].distance)/(parcours.tab[j+1].distance-parcours.tab[j].distance))*(parcours.tab[j+1].x-parcours.tab[j].x) + parcours.tab[j].x);
                                                        velo.pointY = (int) (((velo.distanceParcourue-parcours.tab[j].distance)/(parcours.tab[j+1].distance-parcours.tab[j].distance))*(parcours.tab[j+1].y-parcours.tab[j].y) + parcours.tab[j].y);

                                                        if (velo.pente != parcours.tab[j+1].pente)
                                                        {

                                                            velo.pente = parcours.tab[j+1].pente;

                                                            handler.sendMessage(handler.obtainMessage(IncomingHandler.SEND_MESSAGE,"slope:"+Integer.toString(velo.pente)));
                                                        }


                                                }
                                                j++;
                                        }

                                        


                                        for(j=1;j<1+(velo.y-velo.pointY)/8;j++)
                                        {
                                            canvas.drawLine(velo.x , velo.y - 8*j, velo.x, velo.y - 8*j + 4, veloPaint);
                                        }

                                        canvas.drawBitmap(velo.image, velo.x - velo.image.getWidth()/2, hauteurFleche - velo.image.getHeight(), pointPaint);
                                        
                                        canvas.drawText("d: "+(int)velo.distanceParcourue +"m" , velo.x-20, velo.y + velo.image.getHeight() + 10, distancesPaint);
                    
                                        
                                        
                                        
                                        canvas.drawCircle(velo.x, velo.pointY, 5, veloPaint);
                                        canvas.drawCircle(velo.x, velo.pointY, 3, whitePaint);
                             }
                             
                                
                              canvas.drawBitmap(easterEgg.imageEE, easterEgg.xEE, easterEgg.yEE, pointPaint); 
                              canvas.drawBitmap(easterEgg.image, easterEgg.x, easterEgg.y, pointPaint);
                              
                             
                                
		        
		    }
			
//__________________________________________________________________________________________________________________________________________________________	
		    public boolean onTouch(View view, MotionEvent event) {
		
		        Point point = new Point();
		        float yEstimation;
		        
		        point.x = event.getX(0);
		        point.y = event.getY(0);
                        
		        if(touchable == true)
                        {
		        
                            if ((event.getActionIndex () ==1 )&& (event.getActionMasked () == event.ACTION_POINTER_DOWN))
                            {
                                    pointBis.x = event.getX(1);
                                pointBis.y = event.getY(1);
                                pointBis.on = true;
                                oldDistanceOnTouchPoints= FloatMath.sqrt((float)(Math.pow(point.y-pointBis.y,2) +Math.pow(point.x-pointBis.x,2)));

                                }




                            if(!typeChemin.equals("cheminTDF"))
                            {
                                if((pointBis.on == true))
                                {
                                        newDistanceOnTouchPoints= FloatMath.sqrt((float)(Math.pow(point.y-pointBis.y,2) +Math.pow(point.x-pointBis.x,2)));
                                        if (newDistanceOnTouchPoints > oldDistanceOnTouchPoints)
                                    {
                                        echelleZoomer(view);
                                    }
                                        if (newDistanceOnTouchPoints < oldDistanceOnTouchPoints)
                                    {
                                        echelleDezoomer(view);
                                    }
                                        oldDistanceOnTouchPoints= FloatMath.sqrt((float)(Math.pow(point.y-pointBis.y,2) +Math.pow(point.x-pointBis.x,2)));


                                }
                            }

                            if (event.getPointerCount() == 1)
                            {


                                    if (cheminModulable == true)
                                    {

                                            int i=0,j=0;
                                            boolean isPoint = false;

                                            while(i<parcours.getSize())
                                            {
                                                    if (((point.x>parcours.tab[i].x-touchZone)&&(point.x<parcours.tab[i].x+touchZone))&&((point.y>parcours.tab[i].y-touchZone)&&(point.y<parcours.tab[i].y+touchZone)))
                                                    {
                                                        if(parcours.tab[i].distance > velo.distanceParcourue)
                                                        {
                                                            if((point.y>=y_min-10) && (point.y<=y_max+10))
                                                            {



                                                                    parcours.tab[i].y = point.y;
                                                                    if((i>0)&&(i<parcours.getSize()-1))
                                                                    {

                                                                            if((point.x < parcours.tab[i+1].x -ecartPointsMin/2)&&(point.x > parcours.tab[i-1].x +ecartPointsMin/2))
                                                                                    {

                                                                                            parcours.tab[i].x = point.x;
                                                                                    }



                                                                    }

                                                            }
                                                        }

                                                    }

                                                    if ((point.x>parcours.tab[i].x-ecartPointsMin)&&(point.x<parcours.tab[i].x+ecartPointsMin))    			
                                                    {
                                                            isPoint =true;        		
                                                    }

                                                    i++;
                                            }

                                            if(isPoint == false)
                                            {


                                                    if(((point.x > x_depart_init)&&(point.x < x_arrivee_init))&&((point.y>y_min)&&(point.y<y_max)))
                                                            {

                                                            i=0;
                                                            while(point.x>parcours.tab[i].x)
                                                            {
                                                                    i++;
                                                            }


                                                            yEstimation = ((parcours.tab[i].x-point.x)/(parcours.tab[i].x-parcours.tab[i-1].x))*(parcours.tab[i].y-parcours.tab[i-1].y) + parcours.tab[i-1].y;

                                                            if((point.y < yEstimation +10)&&(point.y > yEstimation -10))
                                                            {
                                                                    parcours.setSize(parcours.getSize()+1);
                                                                    parcours.tab[parcours.getSize()-1]= new Point();

                                                                    for(j=parcours.getSize()-1;j>i;j--)
                                                                    {
                                                                            parcours.tab[j].x = parcours.tab[j-1].x;
                                                                            parcours.tab[j].y = parcours.tab[j-1].y;
                                                                    }

                                                                    parcours.tab[i].x = point.x;
                                                                    parcours.tab[i].y = point.y;
                                                            }
                                                            }

                                            }
                                    }




    //_________________________________		        

                                    if(typeChemin.equals("cheminTDF"))
                                    {
                                            if((point.y < y_max) && (point.y>y_min))
                                            {
                                                    if((point.x + touchZone > maPortion.arrivee)&&(point.x - touchZone < maPortion.arrivee))
                                                    {
                                                            if((point.x >= maPortion.xMin )&&(point.x < maPortion.xMax  ))
                                                            {
                                                                    velo.x = maPortion.depart;
                                                                    if((point.x - 2*unKm > maPortion.depart))
                                                                    {
                                                                            maPortion.arrivee = (int) point.x;
                                                                            if(maPortion.arrivee > x_arrivee_init)
                                                                            {
                                                                                maPortion.arrivee = (int) x_arrivee_init;
                                                                            }

                                                                    }
                                                                    else
                                                                    {
                                                                            if(maPortion.depart > x_depart_init)
                                                                            {
                                                                                    maPortion.arrivee = (int) point.x;
                                                                                    maPortion.depart  = maPortion.arrivee - 2*unKm;


                                                                                    if(maPortion.depart < x_depart_init)
                                                                                    {
                                                                                            maPortion.depart =(int) x_depart_init;
                                                                                            maPortion.arrivee = maPortion.depart + 2*unKm;

                                                                                    }
                                                                            }

                                                                    }
                                                            }

                                                    }

                                                    if((point.x + touchZone > maPortion.depart)&&(point.x - touchZone < maPortion.depart))
                                                    {
                                                            if((point.x > maPortion.xMin )&&(point.x < maPortion.xMax  ))
                                                            {
                                                                    velo.x = maPortion.depart;
                                                                    if((point.x + 2*unKm < maPortion.arrivee))
                                                                    {
                                                                            maPortion.depart = (int) point.x;
                                                                            if(maPortion.depart < x_depart_init)
                                                                            {
                                                                                maPortion.depart = (int) x_depart_init;
                                                                            }
                                                                    }
                                                                    else
                                                                    {
                                                                            if(maPortion.arrivee < x_arrivee_init )
                                                                            {
                                                                                    maPortion.depart = (int) point.x;
                                                                                    maPortion.arrivee  = maPortion.depart + 2*unKm;


                                                                                    if(maPortion.arrivee > x_arrivee_init )
                                                                                    {
                                                                                            maPortion.arrivee =(int) x_arrivee_init ;
                                                                                            maPortion.depart = maPortion.arrivee - 2*unKm;

                                                                                    }

                                                                            }
                                                                    }
                                                            }
                                                    }


                                            }

                                    }	
                            }

                            if (event.getActionMasked () == event.ACTION_POINTER_UP)
                            {
                                    pointBis.on = false;

                            }

                            if ((point.x > (easterEgg.x + easterEgg.image.getWidth()/2))&&(point.x < (easterEgg.x + easterEgg.image.getWidth()/2+30)))
                            {

                                if ((point.y > (easterEgg.y-30))&&(point.y < (easterEgg.y + easterEgg.image.getHeight()+30)))
                                {
                                    if (easterEgg.x <easterEgg.oldX + easterEgg.image.getWidth()*2/3)
                                    {
                                        easterEgg.x = (int)point.x -easterEgg.image.getWidth()/2;
                                    }

                                }       
                            }
                            if (event.getAction() == event.ACTION_UP)
                            {
                                easterEgg.x = easterEgg.oldX;
                            }

                            invalidate();

                        }
                        return true;
                    }
		    

		    
		    

public void echelleZoomer(View bouton) {
  	
	  int i = 0;
	  
	  for(i=0;i<=parcours.getSize()-1;i++)
	  {
		  
	  
		  if((-(echelle.ponderation1 - 1)*(y_max) + (echelle.ponderation1*parcours.tab[i].y)) <= y_min)
		  {
			  return;
		  }
		 
		  
	  }
	  
	  i=0;
	  echelle.value = echelle.value / echelle.ponderation1;
	  invalidate();

	  while(i<=parcours.getSize()-1)
	{
		  parcours.tab[i].y= -(echelle.ponderation1 - 1)*(y_max) + (echelle.ponderation1*parcours.tab[i].y);
		  i++;
	}
	  
	  
	 
}

public void echelleDezoomer(View bouton) {
 	 
	  int i = 0;
	  

	  echelle.value = echelle.value * echelle.ponderation1;
	  invalidate();
	  

	  
	  while(i<=parcours.getSize()-1)
  	{
		  parcours.tab[i].y= (parcours.tab[i].y + (y_max)*(echelle.ponderation1 - 1))/echelle.ponderation1;
		  i++;
  	}
  }
		    


public boolean modifierParcoursSelonPortions()
{
        Parcours parcoursBis=  new Parcours();
        int i,j,k;
        
        /*________________________________________________________________
         * vérification que la parcelle n'est pas vide
         * ________________________________________________________________
         */
        j=0;
        for(i=0;i < parcours.getSize();i++)
        {

            if( (parcours.tab[i].x <= maPortion.arrivee)&& (parcours.tab[i].x >= maPortion.depart))
            {
              j++;
            }        
        }
        
        if(j == 0)
        {
            return false;
        }
        
        /*________________________________________________________________
        * mise à jour du parcours selon la parcelle choisie
        * ________________________________________________________________
        */
        parcours.tab[0].setHauteur(hauteurInitiale);
        
        for(i=0;i<parcours.getSize();i++)
        {
            parcoursBis.tab[i] = parcours.tab[i];
        }

        parcours.tab=  new Point[100];


        
        j=0;
        for(i=0;i < parcours.getSize();i++)
        {

            if( (parcoursBis.tab[i].x <= maPortion.arrivee)&& (parcoursBis.tab[i].x >= maPortion.depart))
            {

                parcours.tab[j]= new Point();
                parcours.tab[j].distance = parcoursBis.tab[i].distance;
                parcours.tab[j].hauteur = parcoursBis.tab[i].hauteur;
                parcours.tab[j].y = parcoursBis.tab[i].y;
                j++;
            }        
        }
        
        
        parcours.setSize(j);
        distanceTotale = (int) (parcours.tab[j-1].distance - (parcours.tab[0].distance));
        
        for (k=0;k<j;k++)
        {
            
            if(parcours.getTab()[k].getHauteur() <= parcours.getTab()[pointLePlusBas].getHauteur())
              {
                pointLePlusBas= k;
              }
                                
            
            if(parcours.tab[k].getHauteur() >= hauteurFinale)
            {
                hauteurFinale = (int)(parcours.tab[k].getHauteur());
                
            }

        }
        
        Log.i("point","point le plus bas = "+pointLePlusBas);
        
        hauteurFinale = hauteurFinale - (int)parcours.tab[pointLePlusBas].hauteur;

        
        for(i=0;i<parcours.getSize();i++)
        {
                if(i!=0)
                {
                    parcours.tab[i].distance = parcours.tab[i].distance- parcours.tab[0].distance;
                    //parcours.tab[i].y = parcours.tab[i].y + y_max - parcours.tab[0].y;
                }
                parcours.tab[i].y = parcours.tab[i].y + y_max - parcours.tab[pointLePlusBas].y;
                
                parcours.tab[i].x = (float) (x_depart_init+(x_arrivee_init-x_depart_init)/(distanceTotale )*parcours.tab[i].distance)  ;
                //parcours.tab[i].y= y_max -((float)((((parcours.tab[i].getHauteur()-parcours.tab[0].getHauteur())*(y_max-y_min))/(hauteurFinale)*echelle.value)));
                
                parcours.tab[i].y= y_max -((float)((((parcours.tab[i].getHauteur()-parcours.tab[pointLePlusBas].getHauteur())*(y_max-y_min))/(hauteurFinale)*echelle.value)));
                

        }
        
        parcours.tab[0].distance = 0;
        parcours.tab[0].x = (float) (x_depart_init+(x_arrivee_init-x_depart_init)/(distanceTotale )*parcours.tab[0].distance);
        
        
        typeChemin = "monCheminTDF";

        invalidate();
        return true;
}





}




//__________________________________________________________________________________________________________________________________________________________	







	

	

